home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 07 - 1991 / 07.01 Jan 91 / Jorg Benchmark / Benchmark Source.TEXT
Encoding:
Text File  |  1990-11-26  |  9.8 KB  |  509 lines  |  [TEXT/nX^n]
  1. Listing 1: Benchmarks
  2.  
  3. Matrix multiplication
  4.  
  5.       program matbench
  6.       real*8 a(50,50),b(50,50),c(50,50)
  7.  
  8.       time = second(0.)
  9.       do i=1,50
  10.           do j=1,50
  11.         a(i,j) = i + j*0.01
  12.         b(i,j) = a(i,j)
  13.         end do
  14.       end do
  15.       time = second(0.) - time
  16.       write (*,*) "Time to set up matrices:",time," seconds"
  17.  
  18.       time = second(0.)
  19.       call mat_mult(c,50,a,50,b,50,50,50,50)
  20.       time = second(0.) - time
  21.       write (*,*) "Time to multiply matrices:",time," seconds"
  22.       
  23.       pause
  24.       end
  25.       
  26.       subroutine mat_mult(c,nc,a,na,b,nb,n1,n2,n3)
  27. c      sets c=a.b; c must be different from a or b
  28. c      na,nb,nc are first dimensions
  29. c      n1 n2 n3 are problem dimensions
  30. c      c is n1xn3
  31. c      a    n1 n2
  32. c      b    n2 n3
  33.       real*8 c(nc,n3),a(na,n2),b(nb,n3)
  34.  
  35.       do k=1,n3
  36.           do i = 1,n1
  37.               c(i,k) = 0d0
  38.           end do
  39.           do j=1,n2
  40.               do i=1,n1
  41.                   c(i,k) = c(i,k)+a(i,j)*b(j,k)
  42.               end do
  43.           end do
  44.       end do
  45.       return
  46.       end
  47.  
  48.       FUNCTION SECOND(X)
  49.       CALL UTILIZ(TIME)
  50.       SECOND=TIME
  51.       RETURN
  52.       END
  53.  
  54.       SUBROUTINE UTILIZ(TIME)
  55.       TIME = LONG(362)/60.0
  56.       END
  57.  
  58. Whetstone benchmark
  59.  
  60. C
  61.       PROGRAM WHETSTONE
  62.       DIMENSION E1(4)
  63.       COMMON /A/ E1,J,K,L
  64.       COMMON /B/ T,T2
  65. C     SYNTHETIC BENCHMARK  BY CURNOW/WICHMANN
  66. C     ***************************************
  67. C     INITIALIZE CONSTANTS
  68.       T=0.499975
  69.       T1=0.50025
  70.       T2=2.0
  71. C     READ VALUE OF I, CONTROLLING TOTAL WEIGHT:
  72. C     IF I=10 THE TOTAL WEIGHT IS ONE MILLION WHETSTONE INSTUCTIONS
  73. C
  74.       I=10
  75. C
  76.       CALL UTILIZ(TT1)
  77.       CPU1=SECOND(Z)
  78.       II=I
  79.       N1=0
  80.       N2=12*I
  81.       N3=14*I
  82.       N4=345*I
  83.       N5=0
  84.       N6=210*I
  85.       N7=32*I
  86.       N8=899*I
  87.       N9=616*I
  88.       N10=0
  89.       N11=93*I
  90. C     MODULE 1: SIMPLE IDENTIFIERS
  91.       JJ=100
  92. 99999 CONTINUE
  93.       X1=1.0
  94.       X2=-1.0
  95.       X3=-1.0
  96.       X4=-1.0
  97.       IF (N1) 12,15,12
  98. 12    CONTINUE
  99.       DO 10 I=1,N1
  100.       X1=( X1+X2+X3-X4)*T
  101.       X2=( X1+X2-X3+X4)*T
  102.       X3=( X1-X2+X3+X4)*T
  103.       X4=(-X1+X2+X3+X4)*T
  104. 10    CONTINUE
  105. X     CALL POUT(N1,N1,N1,X1,X2,X3,X4)
  106. 15    CONTINUE
  107. C     MODULE 2: ARRAY ELEMENTS
  108.       E1(1)=1.0
  109.       E1(2)=-1.0
  110.       E1(3)=-1.0
  111.       E1(4)=-1.0
  112.       DO 20 I=1,N2
  113.       E1(1)=( E1(1)+E1(2)+E1(3)-E1(4))*T
  114.       E1(2)=( E1(1)+E1(2)-E1(3)+E1(4))*T
  115.       E1(3)=( E1(1)-E1(2)+E1(3)+E1(4))*T
  116.       E1(4)=(-E1(1)+E1(2)+E1(3)+E1(4))*T
  117. 20    CONTINUE
  118. X     CALL POUT(N2,N3,N2,E1(1),E1(2),E1(3),E1(4))
  119. C     MODULE 3: ARRAY AS PARAMETER
  120.       DO 30 I=1,N3
  121.       CALL PA(E1)
  122. 30    CONTINUE
  123. X     CALL POUT(N3,N2,N2,E1(1),E1(2),E1(3),E1(4))
  124. C     MODULE 4: CONDITIONAL JUMPS
  125.       J=1
  126.       DO 40 I=1,N4
  127.       IF(J.EQ.1) GOTO 42
  128. 41    J=2
  129.       GO TO 43
  130. 42    J=3
  131. 43    IF(J.GT.2) GOTO 45
  132. 44    J=0
  133.       GO TO 46
  134. 45    J=1
  135. 46    IF(J.LT.1) GOTO 48
  136. 47    J=1
  137.       GO TO 40
  138. 48    J=0
  139. 40    CONTINUE
  140. X     CALL POUT(N4,J,J,X1,X2,X3,X4)
  141. C     MODULE 5: OMITTED
  142. C     MODULE 6: INTEGER ARITHMETIC
  143.       J=1
  144.       K=2
  145.       L=3
  146.       DO 60 I=1,N6
  147.       J=J*(K-J)*(L-K)
  148.       K=L*K-(L-J)*K
  149.       L=(L-K)*(K+J)
  150.       E1(L-1)=J+K+L
  151.       E1(K-1)=J*K*L
  152. 60    CONTINUE
  153. X     CALL POUT(N6,J,K,E1(1),E1(2),E1(3),E1(4))
  154. C     MODULE 7: TRIG. FUNCTIONS
  155.       X=0.5
  156.       Y=0.5
  157.       DO 70 I=1,N7
  158.       X=T*ATAN(T2*SIN(X)*COS(X)/(COS(X+Y)+COS(X-Y)-1.0))
  159.       Y=T*ATAN(T2*SIN(Y)*COS(Y)/(COS(X+Y)+COS(X-Y)-1.0))
  160. 70    CONTINUE
  161. X     CALL POUT(N7,J,K,X,X,Y,Y)
  162. C     MODULE 8: PROCEDURE CALLS
  163.       X=1.0
  164.       Y=1.0
  165.       Z=1.0
  166.       DO 80 I=1,N8
  167.       CALL P3(X,Y,Z)
  168. 80    CONTINUE
  169. X     CALL POUT(N8,J,K,X,Y,Z,Z)
  170. C     MODULE 9: ARRAY REFERENCES
  171.       J=1
  172.       K=2
  173.       L=3
  174.       E1(1)=1.0
  175.       E1(2)=2.0
  176.       E1(3)=3.0
  177.       DO 90 I=1,N9
  178.       CALL P0
  179. 90    CONTINUE
  180. X     CALL POUT(N9,J,K,E1(1),E1(2),E1(3),E1(4))
  181. C     MODULE 10: INTEGER ARITHMETIC
  182.       J=2
  183.       K=3
  184.       IF (N10) 97,105,97
  185. 97    CONTINUE
  186.       DO 100 I=1,N10
  187.       J=J+K
  188.       K=J+K
  189.       J=K-J
  190.       K=K-J-J
  191. 100   CONTINUE
  192. X     CALL POUT(N10,J,K,X1,X2,X3,X4)
  193. 105   CONTINUE
  194. C     MODULE 11: STANDARD FUNCTIONS
  195.       X=0.75
  196.       DO 110 I=1,N11
  197.       X=SQRT(EXP(ALOG(X)/T1))
  198. 110   CONTINUE
  199.       JJ=JJ-1
  200.       IF (JJ.GT.0) GOTO 99999
  201. X     CALL POUT(N11,J,K,X,X,X,X)
  202.       CPU2=SECOND(Z)
  203.       CPU2=1000000.0/FLOAT(II)/(CPU2-CPU1)
  204.       WRITE(*,2) CPU2
  205. 2     FORMAT(/// " TOTAL WEIGHT:" ,F10.3," (IN THOUSANDS OF WHETSTONE",
  206.      *       " INSTRUCTIONS)")
  207.        CALL UTILIZ(TT2)
  208.        TTT=TT2-TT1
  209.        WRITE(*,7777)TTT
  210. 7777   FORMAT(' TIME TAKEN  ',F12.4)
  211.       END
  212.       SUBROUTINE PA(E)
  213.       DIMENSION E(4)
  214.       COMMON /B/ T,T2
  215.       J=0
  216. 100   E(1)=( E(1)+E(2)+E(3)-E(4))*T
  217.       E(2)=( E(1)+E(2)-E(3)+E(4))*T
  218.       E(3)=( E(1)-E(2)+E(3)+E(4))*T
  219.       E(3)=(-E(1)+E(2)+E(3)+E(4))/T2
  220.       J=J+1
  221.       IF (J-6) 100,105,105
  222. 105   CONTINUE
  223.       RETURN
  224.       END
  225.       SUBROUTINE P0
  226.       DIMENSION E1(4)
  227.       COMMON /A/ E1,J,K,L
  228.       E1(J)=E1(K)
  229.       E1(K)=E1(L)
  230.       E1(L)=E1(J)
  231.       RETURN
  232.       END
  233.       SUBROUTINE P3(X,Y,Z)
  234.       COMMON /B/ T,T2
  235.       AX=X
  236.       AY=Y
  237.       AX=T*(AX+AY)
  238.       AY=T*(AX+AY)
  239.       Z=(AX+AY)/T2
  240.       RETURN
  241.       END
  242.       SUBROUTINE POUT(N,J,K,X1,X2,X3,X4)
  243.       WRITE(*,4) N
  244.       WRITE(*,4) J
  245.       WRITE(*,4) K
  246.       WRITE(*,3) X1
  247.       WRITE(*,3) X2
  248.       WRITE(*,3) X3
  249.       WRITE(*,3) X3
  250.       WRITE(*,3) X4
  251. 3     FORMAT(1X,E25.15)
  252. 4     FORMAT(1X,I10)
  253.       RETURN
  254.       END
  255.  
  256.       FUNCTION SECOND(X)
  257.       CALL UTILIZ(TIME)
  258.       SECOND=TIME
  259.       RETURN
  260.       END
  261.  
  262.       SUBROUTINE UTILIZ(TIME)
  263.       TIME = LONG(362)/60.0
  264.       END
  265.  
  266. Listing 2: Assembly listing of inner loops of matrix multiply routine
  267.  
  268. LS Fortran, no optimization
  269.  
  270. L10009    EQU    *
  271.  ;  File "matmult.f";  Line         16
  272.         MOVE.L    $FFFFFFF8(A6),D1
  273.         SUB.L    $FFFFFFAC(A6),D1
  274.         ASL.L    #3,D1
  275.         MOVE.L    $FFFFFFF4(A6),D2
  276.         SUB.L    $FFFFFFB8(A6),D2
  277.         MULS.L    $FFFFFFB4(A6),D2
  278.         ADD.L    D1,D2
  279.         MOVE.L    D2,$FFFFFF84(A6)
  280.         MOVE.L    $FFFFFFF8(A6),D1
  281.         SUB.L    $FFFFFFAC(A6),D1
  282.         ASL.L    #3,D1
  283.         MOVE.L    $FFFFFFF4(A6),D2
  284.         SUB.L    $FFFFFFB8(A6),D2
  285.         MULS.L    $FFFFFFB4(A6),D2
  286.         ADD.L    D1,D2
  287.         MOVE.L    D2,$FFFFFF68(A6)
  288.         MOVE.L    $FFFFFFF8(A6),D1
  289.         SUB.L    $FFFFFFC4(A6),D1
  290.         ASL.L    #3,D1
  291.         MOVE.L    $FFFFFFFC(A6),D2
  292.         SUB.L    $FFFFFFD0(A6),D2
  293.         MULS.L    $FFFFFFCC(A6),D2
  294.         ADD.L    D1,D2
  295.         MOVE.L    D2,$FFFFFF6C(A6)
  296.         MOVE.L    $FFFFFFFC(A6),D1
  297.         SUB.L    $FFFFFFDC(A6),D1
  298.         ASL.L    #3,D1
  299.         MOVE.L    $FFFFFFF4(A6),D2
  300.         SUB.L    $FFFFFFE8(A6),D2
  301.         MULS.L    $FFFFFFE4(A6),D2
  302.         ADD.L    D1,D2
  303.         MOVE.L    D2,$FFFFFF70(A6)
  304.         MOVEA.L    $0020(A6),A0
  305.         ADDA.L    $FFFFFF6C(A6),A0
  306.         FMOVE.D    (A0),FP7
  307.         MOVEA.L    $0018(A6),A1
  308.         ADDA.L    $FFFFFF70(A6),A1
  309.         FMUL.D    (A1),FP7
  310.         MOVEA.L    $0028(A6),A1
  311.         ADDA.L    $FFFFFF68(A6),A1
  312.         FADD.D    (A1),FP7
  313.         MOVEA.L    $0028(A6),A1
  314.         ADDA.L    $FFFFFF84(A6),A1
  315.         FMOVE.D    FP7,(A1)
  316.  ;  File "matmult.f";  Line         17
  317.         ADDQ.L    #1,$FFFFFFF8(A6)
  318.         SUBQ.L    #1,D7
  319.         BGT        L10009
  320.  
  321. LS Fortran, -opt=3 optimization
  322.  
  323. L10009    EQU    *
  324.  ;  File "matmult.f";  Line         16
  325.         MOVE.L    $FFFFFF5C(A6),$FFFFFF58(A6)
  326.         MOVE.L    $FFFFFF64(A6),$FFFFFF40(A6)
  327.         MOVEA.L    $0020(A6),A0
  328.         ADDA.L    $FFFFFF60(A6),A0
  329.         FMOVE.D    (A0),FP7
  330.         MOVEA.L    $0018(A6),A1
  331.         ADDA.L    $FFFFFF40(A6),A1
  332.         FMUL.D    (A1),FP7
  333.         MOVEA.L    $0028(A6),A1
  334.         ADDA.L    $FFFFFF58(A6),A1
  335.         FADD.D    (A1),FP7
  336.         FMOVE.D    FP7,(A1)
  337.  ;  File "matmult.f";  Line         17
  338.         MOVEQ    #$0008,D1
  339.         ADD.L    D1,$FFFFFF5C(A6)
  340.         ADD.L    D1,$FFFFFF60(A6)
  341.         ADDQ.L    #1,$FFFFFFF8(A6)
  342.         SUBQ.L    #1,D7
  343.         BGT.S    L10009
  344.  
  345. Absoft Fortran, no optimization
  346.  
  347. L14:
  348.  
  349. ;                c(i,k) = c(i,k)+a(i,j)*b(j,k)
  350.  
  351.     move.l        d3,d2
  352.     sub.l        #$0001,d2
  353.     move.l        (20,a7),d4
  354.     move.l        d4,d6
  355.     sub.l        #$0001,d6
  356.     move.l        (a7),d0
  357.     muls.l        d0,d6
  358.     add.l        d6,d2
  359.     move.l        d3,d6
  360.     sub.l        #$0001,d6
  361.     move.l        (36,a7),d5
  362.     move.l        d5,d7
  363.     sub.l        #$0001,d7
  364.     muls.l        (8,a7),d7
  365.     add.l        d7,d6
  366.     sub.l        #$0001,d5
  367.     move.l        d4,d7
  368.     sub.l        #$0001,d7
  369.     muls.l        (16,a7),d7
  370.     add.l        d7,d5
  371.     move.l        (200,a7),a2
  372.     fmove.d        (a2,d6.l*8),fp2
  373.     move.l        (208,a7),a3
  374.     fmove.d        (a3,d5.l*8),fp3
  375.     fmul.x        fp3,fp2
  376.     move.l        (192,a7),a4
  377.     fmove.d        (a4,d2.l*8),fp4
  378.     fadd.x        fp2,fp4
  379.     move.l        d3,d2
  380.     sub.l        #$0001,d2
  381.     move.l        d4,d5
  382.     sub.l        #$0001,d5
  383.     muls.l        d0,d5
  384.     add.l        d5,d2
  385.     fmove.d        fp4,(a4,d2.l*8)
  386.     add.l        #$0001,d3
  387.     move.l        (44,a7),d6
  388.     move.l        d6,d7
  389.     sub.l        #$0001,d7
  390.  
  391. ;            end do
  392.  
  393.     move.l        d7,(44,a7)
  394. ;  loop bottom branch
  395.     tst.l        d7
  396.     bgt        L14
  397.  
  398. Absoft Fortran, -O optimization
  399.  
  400. L14:
  401.     move.l        d6,d7
  402.     sub.l        #$0001,d7
  403.     move.l        d7,d2
  404.     add.l        (236,a7),d2
  405.     add.l        (240,a7),d7
  406.     fmove.d        (a2,d7.l*8),fp2
  407.     fmul.d        (248,a7),fp2
  408.     fmove.d        (a3,d2.l*8),fp3
  409.     fadd.x        fp2,fp3
  410.     fmove.d        fp3,(a3,d2.l*8)
  411.     add.l        #$0001,d6
  412.     sub.l        #$0001,d4
  413.  
  414. ;            end do
  415.  
  416.     tst.l        d4
  417.     bgt        L14
  418.  
  419. Absoft Fortran, -O -U optimization
  420.  
  421. L27:
  422.     move.l        d4,d2
  423.     sub.l        #$0001,d2
  424.     move.l        d2,d7
  425.     add.l        d3,d7
  426.     add.l        d0,d2
  427.     fmove.d        (a2,d2.l*8),fp2
  428.     fmul.x        fp3,fp2
  429.     fmove.d        (a3,d7.l*8),fp4
  430.     fadd.x        fp2,fp4
  431.     fmove.d        fp4,(a3,d7.l*8)
  432.     move.l        d4,d2
  433.     add.l        #$0001,d2
  434.     move.l        d2,d4
  435.     sub.l        #$0001,d4
  436.     move.l        d4,d7
  437.     add.l        d3,d7
  438.     add.l        d0,d4
  439.     fmove.d        (a2,d4.l*8),fp5
  440.     fmul.x        fp3,fp5
  441.     fmove.d        (a3,d7.l*8),fp6
  442.     fadd.x        fp5,fp6
  443.     fmove.d        fp6,(a3,d7.l*8)
  444.     move.l        d2,d4
  445.     add.l        #$0001,d4
  446.     sub.l        #$0002,d6
  447.  
  448. ;            end do
  449.  
  450.     tst.l        d6
  451.     bgt        L27
  452.     move.l        d4,(28,a7)
  453.  
  454. Absoft Fortran, -O -h4 optimization
  455.  
  456. L27:
  457.     move.l        d4,d2
  458.     sub.l        #$0001,d2
  459.     move.l        d2,d7
  460.     add.l        d3,d7
  461.     add.l        d0,d2
  462.     fmove.d        (a2,d2.l*8),fp2
  463.     fmul.x        fp3,fp2
  464.     fmove.d        (a3,d7.l*8),fp4
  465.     fadd.x        fp2,fp4
  466.     fmove.d        fp4,(a3,d7.l*8)
  467.     move.l        d4,d2
  468.     add.l        #$0001,d2
  469.     move.l        d2,d4
  470.     sub.l        #$0001,d4
  471.     move.l        d4,d7
  472.     add.l        d3,d7
  473.     add.l        d0,d4
  474.     fmove.d        (a2,d4.l*8),fp5
  475.     fmul.x        fp3,fp5
  476.     fmove.d        (a3,d7.l*8),fp6
  477.     fadd.x        fp5,fp6
  478.     fmove.d        fp6,(a3,d7.l*8)
  479.     add.l        #$0001,d2
  480.     move.l        d2,d4
  481.     sub.l        #$0001,d4
  482.     move.l        d4,d7
  483.     add.l        d3,d7
  484.     add.l        d0,d4
  485.     fmove.d        (a2,d4.l*8),fp7
  486.     fmul.x        fp3,fp7
  487.     fmove.d        (a3,d7.l*8),fp0
  488.     fadd.x        fp7,fp0
  489.     fmove.d        fp0,(a3,d7.l*8)
  490.     add.l        #$0001,d2
  491.     move.l        d2,d4
  492.     sub.l        #$0001,d4
  493.     move.l        d4,d7
  494.     add.l        d3,d7
  495.     add.l        d0,d4
  496.     fmove.d        (a2,d4.l*8),fp2
  497.     fmul.x        fp3,fp2
  498.     fmove.d        (a3,d7.l*8),fp1
  499.     fadd.x        fp2,fp1
  500.     fmove.d        fp1,(a3,d7.l*8)
  501.     move.l        d2,d4
  502.     add.l        #$0001,d4
  503.     sub.l        #$0004,d6
  504.  
  505. ;            end do
  506.  
  507.     tst.l        d6
  508.     bgt        L27
  509.